home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / disk / RCS / diskFragIO.c,v < prev    next >
Encoding:
Text File  |  1992-08-31  |  8.9 KB  |  361 lines
  1. head     1.6;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.6
  10. date     91.09.14.15.17.11;  author mendel;  state Exp;
  11. branches ;
  12. next     1.5;
  13.  
  14. 1.5
  15. date     90.03.16.17.41.10;  author jhh;  state Exp;
  16. branches ;
  17. next     1.4;
  18.  
  19. 1.4
  20. date     89.10.02.23.17.55;  author jhh;  state Exp;
  21. branches ;
  22. next     1.3;
  23.  
  24. 1.3
  25. date     89.09.25.12.32.32;  author jhh;  state Exp;
  26. branches ;
  27. next     1.2;
  28.  
  29. 1.2
  30. date     88.10.27.15.30.32;  author nelson;  state Exp;
  31. branches ;
  32. next     1.1;
  33.  
  34. 1.1
  35. date     88.06.02.12.53.43;  author brent;  state Exp;
  36. branches ;
  37. next     ;
  38.  
  39.  
  40. desc
  41. @Fragment aligned I/O to a raw disk.
  42. @
  43.  
  44.  
  45. 1.6
  46. log
  47. @Changes to reflect the old Sprite file system name being OFS and the
  48. addition of LFS.
  49. @
  50. text
  51. @/* 
  52.  * fragIO.c --
  53.  *
  54.  *    Routines to allow fragments to be read and written.
  55.  *
  56.  * Copyright (C) 1986 Regents of the University of California
  57.  * All rights reserved.
  58.  */
  59.  
  60. #ifndef lint
  61. static char rcsid[] = "$Header: /sprite/src/lib/c/disk/RCS/diskFragIO.c,v 1.5 90/03/16 17:41:10 jhh Exp Locker: mendel $ SPRITE (Berkeley)";
  62. #endif not lint
  63.  
  64. #include <disk.h>
  65. #include <stdio.h>
  66.  
  67. #define    SECTORS_PER_FRAG       (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR)
  68.  
  69.  
  70. /*
  71.  *----------------------------------------------------------------------
  72.  *
  73.  * Disk_FragRead --
  74.  *    Read fragments from the disk file at a specified 1K block offset.
  75.  *    This has to use the disk geometry information to figure out
  76.  *    what disk sectors correspond to the block.
  77.  *
  78.  * Results:
  79.  *    0 if could read the disk, -1 if could not.  If couldn't read the disk
  80.  *    then the error is stored in errno.
  81.  *
  82.  * Side effects:
  83.  *    None.
  84.  *
  85.  *----------------------------------------------------------------------
  86.  */
  87. int
  88. Disk_FragRead(openFileID, headerPtr, firstFrag, numFrags, buffer)
  89.     int         openFileID; /* Handle on raw disk */
  90.     Ofs_DomainHeader     *headerPtr; /* Domain header with geometry 
  91.                      * information. */
  92.     int         firstFrag;  /* First frag to read */
  93.     int         numFrags;   /* The number of fragments to read */
  94.     Address         buffer;        /* The buffer to read into */
  95. {
  96.     register Ofs_Geometry    *geoPtr;
  97.     register int    cylinder;
  98.     register int    rotationalSet;
  99.     register int    blockNumber;
  100.     int            sector;
  101.  
  102.     geoPtr = &headerPtr->geometry;
  103.  
  104.     blockNumber        = firstFrag / FS_FRAGMENTS_PER_BLOCK;
  105.     cylinder        = blockNumber / geoPtr->blocksPerCylinder;
  106.     if (geoPtr->rotSetsPerCyl > 0) {
  107.     /*
  108.      * Original mapping scheme using rotational sets.
  109.      */
  110.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  111.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  112.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  113.     
  114.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  115.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  116.          rotationalSet + geoPtr->blockOffset[blockNumber];
  117.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  118.     } else if (geoPtr->rotSetsPerCyl == OFS_SCSI_MAPPING){
  119.     /*
  120.      * New mapping for scsi devices.
  121.      */
  122.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  123.             firstFrag * SECTORS_PER_FRAG - cylinder * 
  124.             geoPtr->blocksPerCylinder * DISK_SECTORS_PER_BLOCK;
  125.     } else {
  126.     return -1;
  127.     }
  128.     return(Disk_SectorRead(openFileID, sector, 
  129.         numFrags * SECTORS_PER_FRAG, buffer));
  130. }
  131.  
  132.  
  133. /*
  134.  *----------------------------------------------------------------------
  135.  *
  136.  * Disk_FragWrite --
  137.  *    Write fragments to the disk file at a specified 1K block offset.
  138.  *    This has to use the disk geometry information to figure out
  139.  *    what disk sectors correspond to the block.
  140.  *
  141.  * Results:
  142.  *    0 if could write the disk, -1 if could not.  If couldn't write the
  143.  *    disk then the error is stored in errno.
  144.  *
  145.  * Side effects:
  146.  *    None.
  147.  *
  148.  *----------------------------------------------------------------------
  149.  */
  150. int
  151. Disk_FragWrite(openFileID, headerPtr, firstFrag, numFrags, buffer)
  152.     int         openFileID; /* Handle on raw disk */
  153.     Ofs_DomainHeader     *headerPtr; /* Domain header with geometry 
  154.                        information. */
  155.     int         firstFrag;  /* First frag to write */
  156.     int         numFrags;   /* The number of fragments to write */
  157.     Address         buffer;        /* The buffer to write out of. */
  158. {
  159.     register Ofs_Geometry *geoPtr;
  160.     register int cylinder;
  161.     register int rotationalSet;
  162.     register int blockNumber;
  163.     int      sector;
  164.  
  165.     geoPtr = &headerPtr->geometry;
  166.  
  167.     blockNumber        = firstFrag / FS_FRAGMENTS_PER_BLOCK;
  168.     cylinder        = blockNumber / geoPtr->blocksPerCylinder;
  169.     if (geoPtr->rotSetsPerCyl > 0) {
  170.     /*
  171.      * Original mapping scheme using rotational sets.
  172.      */
  173.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  174.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  175.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  176.     
  177.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  178.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  179.          rotationalSet + geoPtr->blockOffset[blockNumber];
  180.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  181.     } else if (geoPtr->rotSetsPerCyl == OFS_SCSI_MAPPING){
  182.     /*
  183.      * New mapping for scsi devices.
  184.      */
  185.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  186.             firstFrag * SECTORS_PER_FRAG - cylinder * 
  187.             geoPtr->blocksPerCylinder * DISK_SECTORS_PER_BLOCK;
  188.     } else {
  189.     return -1;
  190.     }
  191.  
  192.      return(Disk_SectorWrite(openFileID, sector,
  193.         numFrags * SECTORS_PER_FRAG, buffer));
  194. }
  195. @
  196.  
  197.  
  198. 1.5
  199. log
  200. @replaced DiskInfo abstraction with Disk_Label
  201. @
  202. text
  203. @d11 1
  204. a11 1
  205. static char rcsid[] = "$Header: /sprite/src/lib/c/disk/RCS/diskFragIO.c,v 1.4 89/10/02 23:17:55 jhh Exp Locker: jhh $ SPRITE (Berkeley)";
  206. d14 1
  207. a14 1
  208. #include "disk.h"
  209. d40 1
  210. a40 1
  211.     Fsdm_DomainHeader     *headerPtr; /* Domain header with geometry 
  212. d46 1
  213. a46 1
  214.     register Fsdm_Geometry    *geoPtr;
  215. d68 1
  216. a68 1
  217.     } else if (geoPtr->rotSetsPerCyl == FSDM_SCSI_MAPPING){
  218. d103 1
  219. a103 1
  220.     Fsdm_DomainHeader     *headerPtr; /* Domain header with geometry 
  221. d109 1
  222. a109 1
  223.     register Fsdm_Geometry *geoPtr;
  224. d131 1
  225. a131 1
  226.     } else if (geoPtr->rotSetsPerCyl == FSDM_SCSI_MAPPING){
  227. @
  228.  
  229.  
  230. 1.4
  231. log
  232. @new scsi disk mapping
  233. @
  234. text
  235. @d11 1
  236. a11 1
  237. static char rcsid[] = "$Header: /sprite/src/lib/c/disk/RCS/diskFragIO.c,v 1.3 89/09/25 12:32:32 jhh Exp Locker: jhh $ SPRITE (Berkeley)";
  238. d14 1
  239. a14 1
  240. #include "diskUtils.h"
  241. @
  242.  
  243.  
  244. 1.3
  245. log
  246. @Conforms to new fs module structure
  247. @
  248. text
  249. @d11 1
  250. a11 1
  251. static char rcsid[] = "$Header: /sprite/src/lib/c/disk/RCS/diskFragIO.c,v 1.2 88/10/27 15:30:32 nelson Exp Locker: jhh $ SPRITE (Berkeley)";
  252. d56 22
  253. a77 8
  254.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  255.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  256.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  257.  
  258.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  259.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  260.          rotationalSet + geoPtr->blockOffset[blockNumber];
  261.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  262. d79 1
  263. a79 1
  264.         numFrags * (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR), buffer));
  265. d119 22
  266. a140 3
  267.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  268.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  269.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  270. d142 2
  271. a143 6
  272.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  273.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  274.          rotationalSet + geoPtr->blockOffset[blockNumber];
  275.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  276.     return(Disk_SectorWrite(openFileID, sector,
  277.         numFrags * (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR), buffer));
  278. @
  279.  
  280.  
  281. 1.2
  282. log
  283. @Ported to the new C library.
  284. @
  285. text
  286. @d11 1
  287. a11 1
  288. static char rcsid[] = "$Header: /sprite/src/lib/c/disk/RCS/diskFragIO.c,v 1.1 88/06/02 12:53:43 brent Exp Locker: nelson $ SPRITE (Berkeley)";
  289. d40 1
  290. a40 1
  291.     FsDomainHeader     *headerPtr; /* Domain header with geometry 
  292. d46 1
  293. a46 1
  294.     register FsGeometry    *geoPtr;
  295. d89 1
  296. a89 1
  297.     FsDomainHeader     *headerPtr; /* Domain header with geometry 
  298. d95 1
  299. a95 1
  300.     register FsGeometry *geoPtr;
  301. @
  302.  
  303.  
  304. 1.1
  305. log
  306. @Initial revision
  307. @
  308. text
  309. @d11 1
  310. a11 1
  311. static char rcsid[] = "$Header: fragIO.c,v 1.4 87/07/14 11:32:35 brent Exp $ SPRITE (Berkeley)";
  312. a13 3
  313. #include "sprite.h"
  314. #include "option.h"
  315. #include "io.h"
  316. d15 1
  317. d23 1
  318. a23 1
  319.  * FragRead --
  320. d29 2
  321. a30 1
  322.  *    The return code from the read.
  323. d37 2
  324. a38 2
  325. ReturnStatus
  326. FragRead(openFileID, headerPtr, firstFrag, numFrags, buffer)
  327. d41 1
  328. a41 1
  329.                        information. */
  330. d46 5
  331. a50 6
  332.     ReturnStatus status;
  333.     register FsGeometry *geoPtr;
  334.     register int cylinder;
  335.     register int rotationalSet;
  336.     register int blockNumber;
  337.     int    sector;
  338. d64 2
  339. a65 3
  340.     status = SectorRead(openFileID, sector, 
  341.         numFrags * (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR), buffer);
  342.     return(status);
  343. d72 1
  344. a72 1
  345.  * FragWrite --
  346. d78 2
  347. a79 1
  348.  *    The return code from the write.
  349. d86 2
  350. a87 2
  351. ReturnStatus
  352. FragWrite(openFileID, headerPtr, firstFrag, numFrags, buffer)
  353. a94 1
  354.     ReturnStatus status;
  355. d113 2
  356. a114 3
  357.     status = SectorWrite(openFileID, sector,
  358.         numFrags * (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR), buffer);
  359.     return(status);
  360. @
  361.